This rule is part of MISRA C++:2023.
MISRA Rule 11.3.2
Category: Advisory
Analysis Type: Decidable,Single Translation Unit
Amplification
Any typedef-name appearing in a declaration [1] is treated as if it were replaced by the type that it denotes.
Note: the pointer decay that occurs when declaring a function parameter of array type introduces a level of pointer
indirection.
Rationale
Use of more than two levels of indirection can seriously impair the ability to understand the behaviour of the code, and therefore should be
avoided.
Example
typedef int8_t * INTPTR1;
using INTPTR2 = int8_t *;
struct s
{
  int8_t *   s1;                                // Compliant
  int8_t **  s2;                                // Compliant
  int8_t *** s3;                                // Non-compliant
};
struct s *   ps1;                               // Compliant
struct s **  ps2;                               // Compliant
struct s *** ps3;                               // Non-compliant
int8_t **  (   *pfunc1 )();                     // Compliant
int8_t **  (  **pfunc2 )();                     // Compliant
int8_t **  ( ***pfunc3 )();                     // Non-compliant
int8_t *** (  **pfunc4 )();                     // Non-compliant
void function( int8_t  *   par1,                // Compliant
               int8_t  **  par2,                // Compliant
               int8_t  *** par3,                // Non-compliant
               INTPTR1 *   par4,                // Compliant
               INTPTR1 *   const * const par5,  // Non-compliant
               int8_t  *   par6[],              // Compliant
               int8_t  **  par7[],              // Non-compliant
               int8_t  ** &par8)                // Compliant
{
   int8_t  *   ptr1;                            // Compliant
   int8_t  **  ptr2;                            // Compliant
   int8_t  *** ptr3;                            // Non-compliant
   INTPTR2 *   ptr4;                            // Compliant
   INTPTR2 *   const * const ptr5;              // Non-compliant
   int8_t  *   ptr6[ 10 ];                      // Compliant
   int8_t  **  ptr7[ 10 ];                      // Compliant
}
Explanation of types:
  -  par1andptr1are of type pointer toint8_t.
-  par2andptr2are of type pointer to pointer toint8_t.
-  par3andptr3are of type pointer to a pointer to a pointer toint8_t. This is three levels and is
  non-compliant.
-  par4andptr4are expanded to a type of pointer to a pointer toint8_t.
-  par5andptr5are expanded to a type of const pointer to a const pointer to a pointer toint8_t. This is
  three levels and is non-compliant.
-  par6is of type pointer to pointer toint8_tbecause arrays are converted to a pointer to the initial element of the
  array.
-  ptr6is of type array of pointers toint8_t.
-  par7is of type pointer to pointer to pointer toint8_tbecause arrays are converted to a pointer to the initial
  element of the array. This is three levels and is non-compliant.
-  ptr7is of type array of pointer to pointer toint8_t. This is compliant.
-  par8is of type reference to pointer to pointer toint8_t. This is compliant.
Glossary
[1] Declaration
A declaration introduces the name of an entity into a translation unit (see [basic.def]/1).
An entity may be declared several times. The first declaration of an entity in a translation unit is
called an introduction [2]. All subsequent declarations are called redeclarations [3].
A definition [4] is a declaration, as described in [basic.def]/2.
[2] Introduction
See declaration [1].
[3] Redeclaration
See declaration [1].
[4] Definition
See declaration [1].
Copyright The MISRA Consortium Limited © 2023